﻿#define  _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <assert.h>
#include <string.h>
#include <stdbool.h>
//int main()
//{
//	int a = 3;
//	const int& rb = a * 3;
//	
//
//	double d = 3.14;
//	const int& rd = d;
//
//	return 0;
//
//}


//非默认构造函数

//class stack
//{
//public:
//
//	stack(int* arr , int capacity, int top )
//	{
//		_arr = arr;
//		_capacity = capacity;
//		_top = top;
//	}
//
//private:
//	int* _arr;
//	int _capacity;
//	int _top;
//};
//
//int main()
//{
//	stack st1(nullptr,4,0);//非默认构造函数，在实例化对象时，需要将参数传入
//
//	return 0;
//}


//不传参的默认构造函数

//class stack
//{
//public:
//
//	stack()
//	{
//		_arr = nullptr;
//		_capacity = 0;
//		_top = 0;
//	}
//
//private:
//	int* _arr;
//	int _capacity;
//	int _top;
//};
//
//int main()
//{
//	stack st1;
//
//	return 0;
//}

//全缺省的默认构造函数

//class stack
//{
//public:
//
//	//stack(int* arr = nullptr, int capacity = 0, int top = 0)
//	//{
//	//	_arr = arr;
//	//	_capacity = capacity;
//	//	_top = top;
//	//}
//
//private:
//	int* _arr;
//	int _capacity;
//	int _top;
//};
//
//int main()
//{
//	stack st1;
//
//	return 0;
//}

//class stack
//{
//public:
//	stack(int* arr = nullptr, int capacity = 0, int top = 0)
//	{
//		_arr = arr;
//		_capacity = capacity;
//		_top = top;
//	}
//
//	~stack()
//	{
//		free(_arr);
//		_arr = nullptr;
//		_capacity = 0;
//		_top = 0;
//	}
//
//	void Push(int x)
//	{
//		if (_capacity == _top)
//		{
//			int newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
//			int* tmp = (int*)realloc(_arr, sizeof(int) * newcapacity);
//			assert(tmp);
//			_arr = tmp;
//			_capacity = newcapacity;
//		}
//		_arr[_top++] = x;
//	}
//
//
//
//private:
//	int* _arr;
//	int _capacity;
//	int _top;
//};

//class queue1
//{
//private:
//	int st1;
//	int st2;
//};
//
//int main()
//{
//	//stack st1;
//	//st1.Push(1);
//	queue1 q;       //对  内置类型成员变量  的初始化没有要求 ,int char 这些都属于内置类型
//					//同样的 当成员变量为内置类型时 ， 析构函数不会对齐处理
//
//	return 0;
//}


//class queue2
//{
//private:
//	stack st1;
//	stack st2;
//};
//
//int main2()
//{
//	//stack st1;
//	//st1.Push(1);
//	queue2 q;       //而对于  ⾃定义类型成员变量  ，要求调⽤这个成员变量的默认构造函数初始化
//					//而对于  成员变量是自定义类型时 ，无论什么情况都会自动调用析构函数
//
//	return 0;
//}




/// /////////////////////////////////////////////////////////////////////////////////////////////

//拷贝构造

//class date
//{
//public:
//	date(int year, int month , int day)
//	{
//		this->_year = year;
//		this->_month = month;
//		this->_day = day;
//	}
//	//date(const date& d)				//未定义拷贝构造时，对内置类型的会完成值拷贝/浅拷贝（一个字节一个字节的拷贝），
//	//{									//对于某些自定义类型，成员变量全是内置类型没有指向什么资源（没有用动态内存开辟什么地址），编译器也可以完成需要的拷贝
//	//	this->_year = d._year;			//但是像 stack 这样的，虽然也都是内置类型，但是 _arr 指向了资源，此时 值拷贝/浅拷贝不符合需求
//	//	this->_month = d._month;		//为什么呢？因为如果仅仅是 值拷贝/浅拷贝，这种一一字节的拷贝，最终会使两个 实例化对象中 _arr 指向同一块地址
//	//	this->_day = d._day;			//而C++又规定了，在对象的生命周期结束时，无论怎样都会调用 析构函数 ，前一次析构会把这块空间释放，并且置为nullptr
//	//}									//再对第二个对象调用析构函数时，会 free(nullptr)这显然是错误的。
//
//
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	date d1(2024,10,13);
//	date d2 = d1;
//	return 0;
//}

//深拷贝

//class stack
//{
//public:
//	stack(int* arr = nullptr, int capacity = 0, int top = 0)
//	{
//		_arr = arr;
//		_capacity = capacity;
//		_top = top;
//	}
//
//	~stack()
//	{
//		free(_arr);
//		_arr = nullptr;
//		_capacity = 0;
//		_top = 0;
//	}
//
//	//深拷贝
//	stack(stack& st)  //是st1的别名
//	{
//		_arr = (int*)malloc(sizeof(int) * st._capacity);
//		assert(_arr);
//		memcpy(_arr, st._arr, sizeof(int) * st._top);
//		_capacity = st._capacity;
//		_top = st._top;
//	}
//
//	void Push(int x)
//	{
//		if (_capacity == _top)
//		{
//			int newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
//			int* tmp = (int*)realloc(_arr, sizeof(int) * newcapacity);
//			assert(tmp);
//			_arr = tmp;
//			_capacity = newcapacity;
//		}
//		_arr[_top++] = x;
//	}
//
//private:
//	int* _arr;
//	int _capacity;
//	int _top;
//};
//
//int main()
//{
//	stack st1;
//	//stack st2(st1);
//	stack st2 = st1;
//	return 0;
//}


////////////////////////////////////////////////////////////////////////////////////////////////


//运算符重载

//class date
//{
//public:
//	date(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	bool operator<(const date& d)
//	{
//		if (_year < d._year)
//		{
//			return true;
//		}
//		else if (_year == d._year && _month < d._month)
//		{
//			return true;
//		}
//		else if (_year == d._year && _month == d._month && _day < d._day)
//		{
//			return true;
//		}
//		return false;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	date d1(2024,10,13);
//	date d2(2024,10,1);
//
//	//bool ret = d1.operator<(d2);
//	bool ret = d1<d2;
//}



/// //////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////


//对于自定义类型成员变量，一定要调用默认构造函数

//class stack
//{
//public:
//	stack(int n = 4)
//	{
//		_arr = (int*)malloc(sizeof(int) * n);
//		assert(_arr);
//		_capacity = n;
//		_top = 0;
//	}
//
//	~stack()
//	{
//		free(_arr);
//		_arr = nullptr;
//		_capacity = 0;
//		_top = 0;
//	}
//
//	void push(int x)
//	{
//		if (_capacity == _top)
//		{
//			int newcapacity = _capacity * 2;
//			int* tmp = (int*)realloc(_arr, sizeof(int) * newcapacity);
//			assert(tmp);
//			_arr = tmp;
//			_capacity = newcapacity;
//		}
//		_arr[_top++] = x;
//	}
//
//	int top()
//	{
//		//if (!empty())
//		//{
//		//	return -1;
//		//}
//		assert(empty());
//
//		return _arr[_top - 1];
//	}
//
//	bool empty()
//	{
//		return _top ;
//	}
//
//private:
//	int* _arr;
//	int _capacity;
//	int _top;
//};
//
//int main()
//{
//	stack st;
//
//	//st.push(1);
//	//st.push(2);
//	//st.push(3);
//	//st.push(4);
//	//st.push(5);
//
//	return 0;
//}


//非默认构造函数

//class date
//{
//public:
//	date(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void print()
//	{
//		std::cout << _year << "/" << _month << "/" << _day << std::endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	date d1(2024, 10, 13);
//	d1.print();
//	return 0;
//}


//默认构造函数——全缺省

//class date
//{
//public:
//	date(int year = 2024, int month = 10, int day= 13)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void print()
//	{
//		std::cout << _year << "/" << _month << "/" << _day << std::endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	date d1;
//	d1.print();
//	return 0;
//}

//默认构造函数——不写构造

//class date
//{
//public:
//
//	void print()
//	{
//		std::cout << _year << "/" << _month << "/" << _day << std::endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	date d1;
//	d1.print();
//	return 0;
//}

//默认构造函数——无参构造

//class date
//{
//public:
//	date()
//	{
//		_year = 2024;
//		_month = 10;
//		_day = 13;
//	}
//
//	void print()
//	{
//		std::cout << _year << "/" << _month << "/" << _day << std::endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	date d1;
//	d1.print();
//	return 0;
//}


//class stack
//{
//public:
//	stack(int n = 4)
//	{
//		_arr = (int*)malloc(sizeof(int) * n);
//		assert(_arr);
//		_capacity = n;
//		_top = 0;
//	}
//
//	~stack()
//	{
//		free(_arr);
//		_arr = nullptr;
//		_capacity = 0;
//		_top = 0;
//	}
//
//	void push(int x)
//	{
//		if (_capacity == _top)
//		{
//			int newcapacity = _capacity * 2;
//			int* tmp = (int*)realloc(_arr, sizeof(int) * newcapacity);
//			assert(tmp);
//			_arr = tmp;
//			_capacity = newcapacity;
//		}
//		_arr[_top++] = x;
//	}
//
//	int top()
//	{
//		//if (!empty())
//		//{
//		//	return -1;
//		//}
//		assert(empty());
//
//		return _arr[_top - 1];
//	}
//
//	bool empty()
//	{
//		return _top;
//	}
//
//private:
//	int* _arr;
//	int _capacity;
//	int _top;
//};
//
//class queue
//{
//public:
//
//private:
//	stack q1;
//	stack q2;
//};
//
//int main()
//{
//	stack st;
//	queue q;
//
//	//st.push(1);
//	//st.push(2);
//	//st.push(3);
//	//st.push(4);
//	//st.push(5);
//
//	return 0;
//}



///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


//拷贝复制——浅拷贝//值拷贝

//class date
//{
//public:
//	//构造函数
//	date(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	//拷贝构造  d是d1的别名  this 指针指向 d2
//	date(date& d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//
//	void print()
//	{
//		std::cout << _year << "/" << _month << "/" << _day << std::endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	date d1(2024, 10, 13);
//	date d2(d1);
//	d2.print();
//	return 0;
//}


//拷贝复制——深层拷贝

class stack
{
public:
	stack(int n = 4)
	{
		_arr = (int*)malloc(sizeof(int) * n);
		assert(_arr);
		_capacity = n;
		_top = 0;
	}

	stack(stack& st)
	{
		_arr = (int*)malloc(sizeof(int) * st._capacity);
		assert(_arr);
		memcpy(_arr, st._arr, sizeof(int) * st._top);
		_capacity = st._capacity;
		_top = st._top;
	}

	~stack()
	{
		free(_arr);
		_arr = nullptr;
		_capacity = 0;
		_top = 0;
	}

	void push(int x)
	{
		if (_capacity == _top)
		{
			int newcapacity = _capacity * 2;
			int* tmp = (int*)realloc(_arr, sizeof(int) * newcapacity);
			assert(tmp);
			_arr = tmp;
			_capacity = newcapacity;
		}
		_arr[_top++] = x;
	}

	int top()
	{
		//if (!empty())
		//{
		//	return -1;
		//}
		assert(empty());

		return _arr[_top - 1];
	}

	bool empty()
	{
		return _top;
	}

private:
	int* _arr;
	int _capacity;
	int _top;
};

class queue
{
public:

private:
	stack q1;
	stack q2;
};

int main()
{
	//stack st1;
	//stack st2 = st1;

	queue q1;
	queue q2 = q1;

	return 0;
}



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//class date
//{
//public:
//	//构造函数
//	date(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	//拷贝构造  d是d1的别名  this 指针指向 d2
//	date(date& d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//
//	void print()
//	{
//		std::cout << _year << "/" << _month << "/" << _day << std::endl;
//	}
//
//	bool operator<(date& d)
//	{
//		if (_year < d._year)
//		{
//			return true;
//		}
//		else if (_year == d._year && _month < d._month)
//		{
//			return true;
//		}
//		else if (_year == d._year && _month == d._month && _day < d._day)
//		{
//			return true;
//		}
//		return false;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//
//
//int main()
//{
//	date d1(2024, 10, 13);
//	date d2(2024, 10, 5);
//
//	bool ret = d1.operator<(d2);
//	return 0;
//}

//
//int main()
//{
//	int a;
//	int b = 2;
//	int& ra = a;
//	
//	return 0;
//}